/*
+---------------------------------------------------------------------+
| iThinkphp     | [ WE CAN DO IT JUST THINK ]                         |
+---------------------------------------------------------------------+
| Official site | http://www.ithinkphp.org/                           |
+---------------------------------------------------------------------+
| Author        | hello wf585858@yeah.net                             |
+---------------------------------------------------------------------+
| Repository    | https://gitee.com/wf5858585858/iThinkphp            |
+---------------------------------------------------------------------+
| Licensed      | http://www.apache.org/licenses/LICENSE-2.0 )        |
+---------------------------------------------------------------------+
*/

(function () {
	function require(name)
	{
		var module = require.modules[name];
		if (!module) throw new Error('failed to require "' + name + '"');
		if (!("exports" in module) && typeof module.definition === "function")
		{
			module.client = module.component = true;
			module.definition.call(this, module.exports = {}, module);
			delete module.definition
		}
		return module.exports
	}

	require.loader = "component";
	require.helper = {};
	require.helper.semVerSort = function (a, b) {
		var aArray = a.version.split(".");
		var bArray = b.version.split(".");
		for (var i = 0; i < aArray.length; ++i)
		{
			var aInt = parseInt(aArray[i], 10);
			var bInt = parseInt(bArray[i], 10);
			if (aInt === bInt)
			{
				var aLex = aArray[i].substr(("" + aInt).length);
				var bLex = bArray[i].substr(("" + bInt).length);
				if (aLex === "" && bLex !== "") return 1;
				if (aLex !== "" && bLex === "") return -1;
				if (aLex !== "" && bLex !== "") return aLex > bLex ? 1 : -1;
				continue
			}
			else if (aInt > bInt)
			{
				return 1
			}
			else
			{
				return -1
			}
		}
		return 0
	};
	require.latest = function (name, returnPath) {
		function showError(name)
		{
			throw new Error('failed to find latest module of "' + name + '"')
		}

		var versionRegexp = /(.*)~(.*)@v?(\d+\.\d+\.\d+[^\/]*)$/;
		var remoteRegexp = /(.*)~(.*)/;
		if (!remoteRegexp.test(name)) showError(name);
		var moduleNames = Object.keys(require.modules);
		var semVerCandidates = [];
		var otherCandidates = [];
		for (var i = 0; i < moduleNames.length; i++)
		{
			var moduleName = moduleNames[i];
			if (new RegExp(name + "@").test(moduleName))
			{
				var version = moduleName.substr(name.length + 1);
				var semVerMatch = versionRegexp.exec(moduleName);
				if (semVerMatch != null)
				{
					semVerCandidates.push({
						version: version,
						name   : moduleName
					})
				}
				else
				{
					otherCandidates.push({
						version: version,
						name   : moduleName
					})
				}
			}
		}
		if (semVerCandidates.concat(otherCandidates).length === 0)
		{
			showError(name)
		}
		if (semVerCandidates.length > 0)
		{
			var module = semVerCandidates.sort(require.helper.semVerSort).pop().name;
			if (returnPath === true)
			{
				return module
			}
			return require(module)
		}
		var module = otherCandidates.sort(function (a, b) {
			return a.name > b.name
		})[0].name;
		if (returnPath === true)
		{
			return module
		}
		return require(module)
	};
	require.modules = {};
	require.register = function (name, definition) {
		require.modules[name] = {
			definition: definition
		}
	};
	require.define = function (name, exports) {
		require.modules[name] = {
			exports: exports
		}
	};


	require.register("abpetkov~transitionize@0.0.3",
		function (exports, module) {
			module.exports = Transitionize;

			function Transitionize(element, props)
			{
				if (!(this instanceof Transitionize)) return new Transitionize(element, props);
				this.element = element;
				this.props = props || {};
				this.init()
			}

			Transitionize.prototype.isSafari = function () {
				return /Safari/.test(navigator.userAgent) && /Apple Computer/.test(navigator.vendor)
			};
			Transitionize.prototype.init = function () {
				var transitions = [];
				for (var key in this.props)
				{
					transitions.push(key + " " + this.props[key])
				}
				this.element.style.transition = transitions.join(", ");
				if (this.isSafari()) this.element.style.webkitTransition = transitions.join(", ")
			}
		});
	require.register("ftlabs~fastclick@v0.6.11",
		function (exports, module) {
			function FastClick(layer)
			{
				"use strict";
				var oldOnClick, self = this;
				this.trackingClick = false;
				this.trackingClickStart = 0;
				this.targetElement = null;
				this.touchStartX = 0;
				this.touchStartY = 0;
				this.lastTouchIdentifier = 0;
				this.touchBoundary = 10;
				this.layer = layer;
				if (!layer || !layer.nodeType)
				{
					throw new TypeError("Layer must be a document node")
				}
				this.onClick = function () {
					return FastClick.prototype.onClick.apply(self, arguments)
				};
				this.onMouse = function () {
					return FastClick.prototype.onMouse.apply(self, arguments)
				};
				this.onTouchStart = function () {
					return FastClick.prototype.onTouchStart.apply(self, arguments)
				};
				this.onTouchMove = function () {
					return FastClick.prototype.onTouchMove.apply(self, arguments)
				};
				this.onTouchEnd = function () {
					return FastClick.prototype.onTouchEnd.apply(self, arguments)
				};
				this.onTouchCancel = function () {
					return FastClick.prototype.onTouchCancel.apply(self, arguments)
				};
				if (FastClick.notNeeded(layer))
				{
					return
				}
				if (this.deviceIsAndroid)
				{
					layer.addEventListener("mouseover", this.onMouse, true);
					layer.addEventListener("mousedown", this.onMouse, true);
					layer.addEventListener("mouseup", this.onMouse, true)
				}
				layer.addEventListener("click", this.onClick, true);
				layer.addEventListener("touchstart", this.onTouchStart, false);
				layer.addEventListener("touchmove", this.onTouchMove, false);
				layer.addEventListener("touchend", this.onTouchEnd, false);
				layer.addEventListener("touchcancel", this.onTouchCancel, false);
				if (!Event.prototype.stopImmediatePropagation)
				{
					layer.removeEventListener = function (type, callback, capture) {
						var rmv = Node.prototype.removeEventListener;
						if (type === "click")
						{
							rmv.call(layer, type, callback.hijacked || callback, capture)
						}
						else
						{
							rmv.call(layer, type, callback, capture)
						}
					};
					layer.addEventListener = function (type, callback, capture) {
						var adv = Node.prototype.addEventListener;
						if (type === "click")
						{
							adv.call(layer, type, callback.hijacked || (callback.hijacked = function (event) {
								if (!event.propagationStopped)
								{
									callback(event)
								}
							}), capture)
						}
						else
						{
							adv.call(layer, type, callback, capture)
						}
					}
				}
				if (typeof layer.onclick === "function")
				{
					oldOnClick = layer.onclick;
					layer.addEventListener("click",
						function (event) {
							oldOnClick(event)
						},
						false);
					layer.onclick = null
				}
			}

			FastClick.prototype.deviceIsAndroid = navigator.userAgent.indexOf("Android") > 0;
			FastClick.prototype.deviceIsIOS = /iP(ad|hone|od)/.test(navigator.userAgent);
			FastClick.prototype.deviceIsIOS4 = FastClick.prototype.deviceIsIOS && /OS 4_\d(_\d)?/.test(navigator.userAgent);
			FastClick.prototype.deviceIsIOSWithBadTarget = FastClick.prototype.deviceIsIOS && /OS ([6-9]|\d{2})_\d/.test(navigator.userAgent);
			FastClick.prototype.needsClick = function (target) {
				"use strict";
				switch (target.nodeName.toLowerCase())
				{
					case "button":
					case "select":
					case "textarea":
						if (target.disabled)
						{
							return true
						}
						break;
					case "input":
						if (this.deviceIsIOS && target.type === "file" || target.disabled)
						{
							return true
						}
						break;
					case "label":
					case "video":
						return true
				}
				return /\bneedsclick\b/.test(target.className)
			};
			FastClick.prototype.needsFocus = function (target) {
				"use strict";
				switch (target.nodeName.toLowerCase())
				{
					case "textarea":
						return true;
					case "select":
						return !this.deviceIsAndroid;
					case "input":
						switch (target.type)
						{
							case "button":
							case "checkbox":
							case "file":
							case "image":
							case "radio":
							case "submit":
								return false
						}
						return !target.disabled && !target.readOnly;
					default:
						return /\bneedsfocus\b/.test(target.className)
				}
			};
			FastClick.prototype.sendClick = function (targetElement, event) {
				"use strict";
				var clickEvent, touch;
				if (document.activeElement && document.activeElement !== targetElement)
				{
					document.activeElement.blur()
				}
				touch = event.changedTouches[0];
				clickEvent = document.createEvent("MouseEvents");
				clickEvent.initMouseEvent(this.determineEventType(targetElement), true, true, window, 1, touch.screenX, touch.screenY, touch.clientX, touch.clientY, false, false, false, false, 0, null);
				clickEvent.forwardedTouchEvent = true;
				targetElement.dispatchEvent(clickEvent)
			};
			FastClick.prototype.determineEventType = function (targetElement) {
				"use strict";
				if (this.deviceIsAndroid && targetElement.tagName.toLowerCase() === "select")
				{
					return "mousedown"
				}
				return "click"
			};
			FastClick.prototype.focus = function (targetElement) {
				"use strict";
				var length;
				if (this.deviceIsIOS && targetElement.setSelectionRange && targetElement.type.indexOf("date") !== 0 && targetElement.type !== "time")
				{
					length = targetElement.value.length;
					targetElement.setSelectionRange(length, length)
				}
				else
				{
					targetElement.focus()
				}
			};
			FastClick.prototype.updateScrollParent = function (targetElement) {
				"use strict";
				var scrollParent, parentElement;
				scrollParent = targetElement.fastClickScrollParent;
				if (!scrollParent || !scrollParent.contains(targetElement))
				{
					parentElement = targetElement;
					do
					{
						if (parentElement.scrollHeight > parentElement.offsetHeight)
						{
							scrollParent = parentElement;
							targetElement.fastClickScrollParent = parentElement;
							break
						}
						parentElement = parentElement.parentElement
					} while (parentElement)
				}
				if (scrollParent)
				{
					scrollParent.fastClickLastScrollTop = scrollParent.scrollTop
				}
			};
			FastClick.prototype.getTargetElementFromEventTarget = function (eventTarget) {
				"use strict";
				if (eventTarget.nodeType === Node.TEXT_NODE)
				{
					return eventTarget.parentNode
				}
				return eventTarget
			};
			FastClick.prototype.onTouchStart = function (event) {
				"use strict";
				var targetElement, touch, selection;
				if (event.targetTouches.length > 1)
				{
					return true
				}
				targetElement = this.getTargetElementFromEventTarget(event.target);
				touch = event.targetTouches[0];
				if (this.deviceIsIOS)
				{
					selection = window.getSelection();
					if (selection.rangeCount && !selection.isCollapsed)
					{
						return true
					}
					if (!this.deviceIsIOS4)
					{
						if (touch.identifier === this.lastTouchIdentifier)
						{
							event.preventDefault();
							return false
						}
						this.lastTouchIdentifier = touch.identifier;
						this.updateScrollParent(targetElement)
					}
				}
				this.trackingClick = true;
				this.trackingClickStart = event.timeStamp;
				this.targetElement = targetElement;
				this.touchStartX = touch.pageX;
				this.touchStartY = touch.pageY;
				if (event.timeStamp - this.lastClickTime < 200)
				{
					event.preventDefault()
				}
				return true
			};
			FastClick.prototype.touchHasMoved = function (event) {
				"use strict";
				var touch = event.changedTouches[0],
					boundary = this.touchBoundary;
				if (Math.abs(touch.pageX - this.touchStartX) > boundary || Math.abs(touch.pageY - this.touchStartY) > boundary)
				{
					return true
				}
				return false
			};
			FastClick.prototype.onTouchMove = function (event) {
				"use strict";
				if (!this.trackingClick)
				{
					return true
				}
				if (this.targetElement !== this.getTargetElementFromEventTarget(event.target) || this.touchHasMoved(event))
				{
					this.trackingClick = false;
					this.targetElement = null
				}
				return true
			};
			FastClick.prototype.findControl = function (labelElement) {
				"use strict";
				if (labelElement.control !== undefined)
				{
					return labelElement.control
				}
				if (labelElement.htmlFor)
				{
					return document.getElementById(labelElement.htmlFor)
				}
				return labelElement.querySelector("button, input:not([type=hidden]), keygen, meter, output, progress, select, textarea")
			};
			FastClick.prototype.onTouchEnd = function (event) {
				"use strict";
				var forElement, trackingClickStart, targetTagName, scrollParent, touch,
					targetElement = this.targetElement;
				if (!this.trackingClick)
				{
					return true
				}
				if (event.timeStamp - this.lastClickTime < 200)
				{
					this.cancelNextClick = true;
					return true
				}
				this.cancelNextClick = false;
				this.lastClickTime = event.timeStamp;
				trackingClickStart = this.trackingClickStart;
				this.trackingClick = false;
				this.trackingClickStart = 0;
				if (this.deviceIsIOSWithBadTarget)
				{
					touch = event.changedTouches[0];
					targetElement = document.elementFromPoint(touch.pageX - window.pageXOffset, touch.pageY - window.pageYOffset) || targetElement;
					targetElement.fastClickScrollParent = this.targetElement.fastClickScrollParent
				}
				targetTagName = targetElement.tagName.toLowerCase();
				if (targetTagName === "label")
				{
					forElement = this.findControl(targetElement);
					if (forElement)
					{
						this.focus(targetElement);
						if (this.deviceIsAndroid)
						{
							return false
						}
						targetElement = forElement
					}
				}
				else if (this.needsFocus(targetElement))
				{
					if (event.timeStamp - trackingClickStart > 100 || this.deviceIsIOS && window.top !== window && targetTagName === "input")
					{
						this.targetElement = null;
						return false
					}
					this.focus(targetElement);
					if (!this.deviceIsIOS4 || targetTagName !== "select")
					{
						this.targetElement = null;
						event.preventDefault()
					}
					return false
				}
				if (this.deviceIsIOS && !this.deviceIsIOS4)
				{
					scrollParent = targetElement.fastClickScrollParent;
					if (scrollParent && scrollParent.fastClickLastScrollTop !== scrollParent.scrollTop)
					{
						return true
					}
				}
				if (!this.needsClick(targetElement))
				{
					event.preventDefault();
					this.sendClick(targetElement, event)
				}
				return false
			};
			FastClick.prototype.onTouchCancel = function () {
				"use strict";
				this.trackingClick = false;
				this.targetElement = null
			};
			FastClick.prototype.onMouse = function (event) {
				"use strict";
				if (!this.targetElement)
				{
					return true
				}
				if (event.forwardedTouchEvent)
				{
					return true
				}
				if (!event.cancelable)
				{
					return true
				}
				if (!this.needsClick(this.targetElement) || this.cancelNextClick)
				{
					if (event.stopImmediatePropagation)
					{
						event.stopImmediatePropagation()
					}
					else
					{
						event.propagationStopped = true
					}
					event.stopPropagation();
					event.preventDefault();
					return false
				}
				return true
			};
			FastClick.prototype.onClick = function (event) {
				"use strict";
				var permitted;
				if (this.trackingClick)
				{
					this.targetElement = null;
					this.trackingClick = false;
					return true
				}
				if (event.target.type === "submit" && event.detail === 0)
				{
					return true
				}
				permitted = this.onMouse(event);
				if (!permitted)
				{
					this.targetElement = null
				}
				return permitted
			};
			FastClick.prototype.destroy = function () {
				"use strict";
				var layer = this.layer;
				if (this.deviceIsAndroid)
				{
					layer.removeEventListener("mouseover", this.onMouse, true);
					layer.removeEventListener("mousedown", this.onMouse, true);
					layer.removeEventListener("mouseup", this.onMouse, true)
				}
				layer.removeEventListener("click", this.onClick, true);
				layer.removeEventListener("touchstart", this.onTouchStart, false);
				layer.removeEventListener("touchmove", this.onTouchMove, false);
				layer.removeEventListener("touchend", this.onTouchEnd, false);
				layer.removeEventListener("touchcancel", this.onTouchCancel, false)
			};
			FastClick.notNeeded = function (layer) {
				"use strict";
				var metaViewport;
				var chromeVersion;
				if (typeof window.ontouchstart === "undefined")
				{
					return true
				}
				chromeVersion = +(/Chrome\/([0-9]+)/.exec(navigator.userAgent) || [, 0])[1];
				if (chromeVersion)
				{
					if (FastClick.prototype.deviceIsAndroid)
					{
						metaViewport = document.querySelector("meta[name=viewport]");
						if (metaViewport)
						{
							if (metaViewport.content.indexOf("user-scalable=no") !== -1)
							{
								return true
							}
							if (chromeVersion > 31 && window.innerWidth <= window.screen.width)
							{
								return true
							}
						}
					}
					else
					{
						return true
					}
				}
				if (layer.style.msTouchAction === "none")
				{
					return true
				}
				return false
			};
			FastClick.attach = function (layer) {
				"use strict";
				return new FastClick(layer)
			};
			if (typeof define !== "undefined" && define.amd)
			{
				define(function () {
					"use strict";
					return FastClick
				})
			}
			else if (typeof module !== "undefined" && module.exports)
			{
				module.exports = FastClick.attach;
				module.exports.FastClick = FastClick
			}
			else
			{
				window.FastClick = FastClick
			}
		});
	require.register("component~indexof@0.0.3",
		function (exports, module) {
			module.exports = function (arr, obj) {
				if (arr.indexOf) return arr.indexOf(obj);
				for (var i = 0; i < arr.length; ++i)
				{
					if (arr[i] === obj) return i
				}
				return -1
			}
		});
	require.register("component~classes@1.2.1",
		function (exports, module) {
			var index = require("component~indexof@0.0.3");
			var re = /\s+/;
			var toString = Object.prototype.toString;
			module.exports = function (el) {
				return new ClassList(el)
			};

			function ClassList(el)
			{
				if (!el) throw new Error("A DOM element reference is required");
				this.el = el;
				this.list = el.classList
			}

			ClassList.prototype.add = function (name) {
				if (this.list)
				{
					this.list.add(name);
					return this
				}
				var arr = this.array();
				var i = index(arr, name);
				if (!~i) arr.push(name);
				this.el.className = arr.join(" ");
				return this
			};
			ClassList.prototype.remove = function (name) {
				if ("[object RegExp]" == toString.call(name))
				{
					return this.removeMatching(name)
				}
				if (this.list)
				{
					this.list.remove(name);
					return this
				}
				var arr = this.array();
				var i = index(arr, name);
				if (~i) arr.splice(i, 1);
				this.el.className = arr.join(" ");
				return this
			};
			ClassList.prototype.removeMatching = function (re) {
				var arr = this.array();
				for (var i = 0; i < arr.length; i++)
				{
					if (re.test(arr[i]))
					{
						this.remove(arr[i])
					}
				}
				return this
			};
			ClassList.prototype.toggle = function (name, force) {
				if (this.list)
				{
					if ("undefined" !== typeof force)
					{
						if (force !== this.list.toggle(name, force))
						{
							this.list.toggle(name)
						}
					}
					else
					{
						this.list.toggle(name)
					}
					return this
				}
				if ("undefined" !== typeof force)
				{
					if (!force)
					{
						this.remove(name)
					}
					else
					{
						this.add(name)
					}
				}
				else
				{
					if (this.has(name))
					{
						this.remove(name)
					}
					else
					{
						this.add(name)
					}
				}
				return this
			};
			ClassList.prototype.array = function () {
				var str = this.el.className.replace(/^\s+|\s+$/g, "");
				var arr = str.split(re);
				if ("" === arr[0]) arr.shift();
				return arr
			};
			ClassList.prototype.has = ClassList.prototype.contains = function (name) {
				return this.list ? this.list.contains(name) : !!~index(this.array(), name)
			}
		});
	require.register("component~event@0.1.4",
		function (exports, module) {
			var bind = window.addEventListener ? "addEventListener" : "attachEvent",
				unbind = window.removeEventListener ? "removeEventListener" : "detachEvent",
				prefix = bind !== "addEventListener" ? "on" : "";
			exports.bind = function (el, type, fn, capture) {
				el[bind](prefix + type, fn, capture || false);
				return fn
			};
			exports.unbind = function (el, type, fn, capture) {
				el[unbind](prefix + type, fn, capture || false);
				return fn
			}
		});
	require.register("component~query@0.0.3",
		function (exports, module) {
			function one(selector, el)
			{
				return el.querySelector(selector)
			}

			exports = module.exports = function (selector, el) {
				el = el || document;
				return one(selector, el)
			};
			exports.all = function (selector, el) {
				el = el || document;
				return el.querySelectorAll(selector)
			};
			exports.engine = function (obj) {
				if (!obj.one) throw new Error(".one callback required");
				if (!obj.all) throw new Error(".all callback required");
				one = obj.one;
				exports.all = obj.all;
				return exports
			}
		});
	require.register("component~matches-selector@0.1.5",
		function (exports, module) {
			var query = require("component~query@0.0.3");
			var proto = Element.prototype;
			var vendor = proto.matches || proto.webkitMatchesSelector || proto.mozMatchesSelector || proto.msMatchesSelector || proto.oMatchesSelector;
			module.exports = match;

			function match(el, selector)
			{
				if (!el || el.nodeType !== 1) return false;
				if (vendor) return vendor.call(el, selector);
				var nodes = query.all(selector, el.parentNode);
				for (var i = 0; i < nodes.length; ++i)
				{
					if (nodes[i] == el) return true
				}
				return false
			}
		});
	require.register("component~closest@0.1.4",
		function (exports, module) {
			var matches = require("component~matches-selector@0.1.5");
			module.exports = function (element, selector, checkYoSelf, root) {
				element = checkYoSelf ? {
					parentNode: element
				} : element;
				root = root || document;
				while ((element = element.parentNode) && element !== document)
				{
					if (matches(element, selector)) return element;
					if (element === root) return
				}
			}
		});
	require.register("component~delegate@0.2.3",
		function (exports, module) {
			var closest = require("component~closest@0.1.4"),
				event = require("component~event@0.1.4");
			exports.bind = function (el, selector, type, fn, capture) {
				return event.bind(el, type,
					function (e) {
						var target = e.target || e.srcElement;
						e.delegateTarget = closest(target, selector, true, el);
						if (e.delegateTarget) fn.call(el, e)
					},
					capture)
			};
			exports.unbind = function (el, type, fn, capture) {
				event.unbind(el, type, fn, capture)
			}
		});
	require.register("component~events@1.0.9",
		function (exports, module) {
			var events = require("component~event@0.1.4");
			var delegate = require("component~delegate@0.2.3");
			module.exports = Events;

			function Events(el, obj)
			{
				if (!(this instanceof Events)) return new Events(el, obj);
				if (!el) throw new Error("element required");
				if (!obj) throw new Error("object required");
				this.el = el;
				this.obj = obj;
				this._events = {}
			}

			Events.prototype.sub = function (event, method, cb) {
				this._events[event] = this._events[event] || {};
				this._events[event][method] = cb
			};
			Events.prototype.bind = function (event, method) {
				var e = parse(event);
				var el = this.el;
				var obj = this.obj;
				var name = e.name;
				var method = method || "on" + name;
				var args = [].slice.call(arguments, 2);

				function cb()
				{
					var a = [].slice.call(arguments).concat(args);
					obj[method].apply(obj, a)
				}

				if (e.selector)
				{
					cb = delegate.bind(el, e.selector, name, cb)
				}
				else
				{
					events.bind(el, name, cb)
				}
				this.sub(name, method, cb);
				return cb
			};
			Events.prototype.unbind = function (event, method) {
				if (0 == arguments.length) return this.unbindAll();
				if (1 == arguments.length) return this.unbindAllOf(event);
				var bindings = this._events[event];
				if (!bindings) return;
				var cb = bindings[method];
				if (!cb) return;
				events.unbind(this.el, event, cb)
			};
			Events.prototype.unbindAll = function () {
				for (var event in this._events)
				{
					this.unbindAllOf(event)
				}
			};
			Events.prototype.unbindAllOf = function (event) {
				var bindings = this._events[event];
				if (!bindings) return;
				for (var method in bindings)
				{
					this.unbind(event, method)
				}
			};

			function parse(event)
			{
				var parts = event.split(/ +/);
				return {
					name    : parts.shift(),
					selector: parts.join(" ")
				}
			}
		});





	require.register("switchery",
		function (exports, module) {
			var transitionize = require("abpetkov~transitionize@0.0.3"),
				fastclick = require("ftlabs~fastclick@v0.6.11"),
				classes = require("component~classes@1.2.1"),
				events = require("component~events@1.0.9");
			module.exports = Switchery;
			var defaults = {
				color             : "#64bd63",
				secondaryColor    : "#dfdfdf",
				jackColor         : "#fff",
				jackSecondaryColor: null,
				className         : "switchery",
				disabled          : false,
				disabledOpacity   : .5,
				speed             : "0.4s",
				size              : "default"
			};

			function Switchery(element, options)
			{
				if (!(this instanceof Switchery)) return new Switchery(element, options);
				this.element = element;
				this.isAuto = true;
				this.options = options || {};
				for (var i in defaults)
				{
					if (this.options[i] == null)
					{
						this.options[i] = defaults[i]
					}
				}
				if (this.element != null && this.element.type == "checkbox") this.init();
				if (this.isDisabled() === true) this.disable()
			}

			Switchery.prototype.hide = function () {
				this.element.style.display = "none"
			};
			Switchery.prototype.show = function () {
				var switcher = this.create();
				this.insertAfter(this.element, switcher)
			};
			Switchery.prototype.create = function () {
				this.switcher = document.createElement("span");
				this.jack = document.createElement("small");
				this.switcher.appendChild(this.jack);
				this.switcher.className = this.options.className;
				this.events = events(this.switcher, this);
				return this.switcher
			};
			Switchery.prototype.insertAfter = function (reference, target) {
				reference.parentNode.insertBefore(target, reference.nextSibling)
			};
			Switchery.prototype.check = function () {
				this.setStatus(true)
			};
			Switchery.prototype.uncheck = function () {
				this.setStatus(false)
			};
			Switchery.prototype.toggleStatus = function () {
				this.setStatus(this.isChecked())
			};
			Switchery.prototype.setStatus = function (status) {
				this.element.checked = !!status;
				this.setPosition(true)
			};


			Switchery.prototype.setPosition = function (clicked) {
				var checked = this.isChecked(),
					switcher = this.switcher,
					jack = this.jack;
				if (clicked && checked) checked = false;
				else if (clicked && !checked) checked = true;
				if (checked === true)
				{
					this.element.checked = true;
					if (window.getComputedStyle) jack.style.left = parseInt(window.getComputedStyle(switcher).width) - parseInt(window.getComputedStyle(jack).width) + "px";
					else jack.style.left = parseInt(switcher.currentStyle["width"]) - parseInt(jack.currentStyle["width"]) + "px";
					if (this.options.color) this.colorize();
					this.setSpeed()
				}
				else
				{
					jack.style.left = 0;
					this.element.checked = false;
					this.switcher.style.boxShadow = "inset 0 0 0 0 " + this.options.secondaryColor;
					this.switcher.style.borderColor = this.options.secondaryColor;
					this.switcher.style.backgroundColor = this.options.secondaryColor !== defaults.secondaryColor ? this.options.secondaryColor : "#fff";
					this.jack.style.backgroundColor = this.options.jackSecondaryColor !== this.options.jackColor ? this.options.jackSecondaryColor : this.options.jackColor;
					this.setSpeed()
				}
			};
			Switchery.prototype.setSpeed = function () {
				var switcherProp = {},
					jackProp = {
						"background-color": this.options.speed,
						left              : this.options.speed.replace(/[a-z]/, "") / 2 + "s"
					};
				if (this.isChecked())
				{
					switcherProp = {
						border            : this.options.speed,
						"box-shadow"      : this.options.speed,
						"background-color": this.options.speed.replace(/[a-z]/, "") * 3 + "s"
					}
				}
				else
				{
					switcherProp = {
						border      : this.options.speed,
						"box-shadow": this.options.speed
					}
				}
				transitionize(this.switcher, switcherProp);
				transitionize(this.jack, jackProp)
			};
			Switchery.prototype.setSize = function () {
				var small = "switchery-small",
					normal = "switchery-default",
					large = "switchery-large";
				switch (this.options.size)
				{
					case "small":
						classes(this.switcher).add(small);
						break;
					case "large":
						classes(this.switcher).add(large);
						break;
					default:
						classes(this.switcher).add(normal);
						break
				}
			};
			Switchery.prototype.colorize = function () {
				var switcherHeight = this.switcher.offsetHeight / 2;
				this.switcher.style.backgroundColor = this.options.color;
				this.switcher.style.borderColor = this.options.color;
				this.switcher.style.boxShadow = "inset 0 0 0 " + switcherHeight + "px " + this.options.color;
				this.jack.style.backgroundColor = this.options.jackColor
			};
			Switchery.prototype.handleOnchange = function (state) {
				if (document.dispatchEvent)
				{
					var event = document.createEvent("HTMLEvents");
					event.initEvent("change", true, true);
					this.element.dispatchEvent(event)
				}
				else
				{
					this.element.fireEvent("onchange")
				}
			};
			Switchery.prototype.handleChange = function () {
				var self = this,
					el = this.element;
				if (el.addEventListener)
				{
					el.addEventListener("change",
						function () {
							self.setPosition()
						})
				}
				else
				{
					el.attachEvent("onchange",
						function () {
							self.setPosition()
						})
				}
			};


			Switchery.prototype.auto = function (isAuto) {
				this.isAuto = isAuto;
			};

			Switchery.prototype.handleClick = function () {
				var switcher = this.switcher;
				fastclick(switcher);
				this.events.bind("click", "bindClick")
			};

			Switchery.prototype.bindClick = function () {
				if (this.isAuto)
				{
					this.toggleStatus();
				}
				this.handleOnchange(this.element.checked)

				// var parent = this.element.parentNode.tagName.toLowerCase(),
				// 	labelParent = parent === "label" ? false : true;
				// this.setPosition(labelParent);
				// this.handleOnchange(this.element.checked)

			};


			Switchery.prototype.markAsSwitched = function () {
				this.element.setAttribute("data-switchery", true)
			};
			Switchery.prototype.markedAsSwitched = function () {
				return this.element.getAttribute("data-switchery")
			};
			Switchery.prototype.init = function () {
				this.hide();
				this.show();
				this.setSize();
				this.setPosition();
				this.markAsSwitched();
				this.handleChange();
				this.handleClick()
			};
			Switchery.prototype.isChecked = function () {
				return this.element.checked
			};
			Switchery.prototype.isDisabled = function () {
				return this.options.disabled || this.element.disabled || this.element.readOnly
			};
			Switchery.prototype.destroy = function () {
				this.events.unbind()
			};
			Switchery.prototype.enable = function () {
				if (!this.options.disabled) return;
				if (this.options.disabled) this.options.disabled = false;
				if (this.element.disabled) this.element.disabled = false;
				if (this.element.readOnly) this.element.readOnly = false;
				this.switcher.style.opacity = 1;
				this.events.bind("click", "bindClick")
			};
			Switchery.prototype.disable = function () {
				if (this.options.disabled) return;
				if (!this.options.disabled) this.options.disabled = true;
				if (!this.element.disabled) this.element.disabled = true;
				if (!this.element.readOnly) this.element.readOnly = true;
				this.switcher.style.opacity = this.options.disabledOpacity;
				this.destroy()
			}
		});
	if (typeof exports == "object")
	{
		module.exports = require("switchery")
	}
	else if (typeof define == "function" && define.amd)
	{
		define("Switchery", [],
			function () {
				return require("switchery")
			})
	}
	else
	{
		(this || window)["Switchery"] = require("switchery")
	}
})();